std::map::operator[]

#include <map>

mapped_type& operator[](const key_type& key);
mapped_type& operator[](key_type&& key); // (since C++11)

Truy cập phần tử có key tương ứng trong std::map. Điểm đặc biệt của toán tử này là nếu key chưa tồn tại trong std::map, nó sẽ tự động chèn một phần tử mới với key đó và value được khởi tạo mặc định (default-constructed).

Tham số

key

• Giá trị của key cần truy cập hoặc chèn.

Giá trị trả về

mapped_type&

• Trả về một tham chiếu có thể đọc và ghi đến value tương ứng với key key.
  • Nếu key đã tồn tại trong std::map, tham chiếu sẽ trỏ đến value hiện tại của phần tử đó.
  • Nếu key chưa tồn tại, một phần tử mới với key là key và value được khởi tạo mặc định sẽ được chèn vào std::map, và tham chiếu sẽ trỏ đến value mới được khởi tạo đó.

Đặc điểm

1. Truy cập và chèn: Toán tử [] vừa cho phép truy cập phần tử có sẵn, vừa tự động chèn phần tử mới nếu key chưa tồn tại.
2. Tham chiếu: Toán tử [] trả về tham chiếu đến value, cho phép bạn thay đổi trực tiếp giá trị của value.
3. Khởi tạo mặc định: Nếu key chưa tồn tại, phần tử mới được chèn vào sẽ có value được khởi tạo mặc định (ví dụ: 0 cho int, "" cho std::string, ...).
4. Không const: Toán tử [] không phải là hàm const vì nó có thể thay đổi nội dung của std::map (khi chèn phần tử mới).
5. Phân biệt với at(): at() cũng dùng để truy cập phần tử theo key nhưng at() ném ra ngoại lệ std::out_of_range nếu key không tồn tại, trong khi operator[] sẽ chèn phần tử mới.
6. Cẩn thận với việc chèn không mong muốn: Vì operator[] tự động chèn phần tử mới nếu key chưa tồn tại, bạn cần cẩn thận để tránh việc vô tình chèn các phần tử không mong muốn vào std::map. Nếu bạn chỉ muốn kiểm tra sự tồn tại của key, hãy sử dụng find() hoặc count().
7. Không sử dụng với const std::map: Bạn không thể sử dụng toán tử [] với const std::map vì nó có thể thay đổi nội dung của map.
8. Độ phức tạp: Độ phức tạp của operator[] là O(log n), với n là số phần tử trong std::map.

Ví dụ

Truy cập và gán giá trị

#include <iostream>
#include <map>
#include <string>

int main() {
  std::map<std::string, int> mymap;

  // Chèn các phần tử sử dụng toán tử []
  mymap["apple"] = 1;
  mymap["banana"] = 2;
  mymap["orange"] = 3;

  // Truy cập phần tử sử dụng toán tử []
  std::cout << "mymap[\"banana\"]: " << mymap["banana"] << '\n'; // Output: mymap["banana"]: 2

  // Thay đổi giá trị của phần tử sử dụng toán tử []
  mymap["apple"] = 5;

  // Truy cập phần tử không tồn tại (sẽ được chèn vào)
  std::cout << "mymap[\"grape\"]: " << mymap["grape"] << '\n'; // Output: mymap["grape"]: 0 (giá trị mặc định của int)
  // Lúc này, "grape": 0 đã được thêm vào map

  std::cout << "mymap after accessing non-existing key:\n";
  for (const auto& pair : mymap) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // mymap after accessing non-existing key:
  // apple: 5
  // banana: 2
  // grape: 0
  // orange: 3

  return 0;
}

Các hàm liên quan

find	Tìm kiếm một phần tử có key bằng với giá trị key cho trước trong std::map
insert	Chèn một phần tử mới (cặp key-value) vào std::map
=	Gán nội dung của một std::map khác hoặc một initializer_list cho std::map hiện tại